import * as api from '@/api/api'
import { isURL } from '@/utils/validate'
// import onlineCommons from '@jeecg/antd-online-mini'
import moment from 'moment'
export function timeFix() {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : (hour <= 11 ? '上午好' : (hour <= 13 ? '中午好' : (hour < 20 ? '下午好' : '晚上好')))
}

export function welcome() {
  const arr = ['休息一会儿吧', '准备吃什么呢?', '要不要打一把 DOTA', '我猜你可能累了']
  const index = Math.floor((Math.random() * arr.length))
  return arr[index]
}

/**
 * 触发 window.resize
 */
export function triggerWindowResizeEvent() {
  const event = document.createEvent('HTMLEvents')
  event.initEvent('resize', true, true)
  event.eventType = 'message'
  window.dispatchEvent(event)
}

/**
 * 过滤对象中为空的属性
 * @param obj
 * @returns {*}
 */
export function filterObj(obj) {
  if (!(typeof obj === 'object')) {
    return
  }

  for (const key in obj) {
    if (obj.hasOwnProperty(key) &&
      (obj[key] == null || obj[key] == undefined || obj[key] === '')) {
      delete obj[key]
    }
  }
  return obj
}

/**
 * 时间格式化
 * @param value
 * @param fmt
 * @returns {*}
 */
export function formatDate(value, fmt) {
  const regPos = /^\d+(\.\d+)?$/
  if (regPos.test(value)) {
    // 如果是数字
    const getDate = new Date(value)
    const o = {
      'M+': getDate.getMonth() + 1,
      'd+': getDate.getDate(),
      'h+': getDate.getHours(),
      'm+': getDate.getMinutes(),
      's+': getDate.getSeconds(),
      'q+': Math.floor((getDate.getMonth() + 3) / 3),
      'S': getDate.getMilliseconds()
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (getDate.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (const k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? (o[k]) : (('00' + o[k]).substr(('' + o[k]).length)))
      }
    }
    return fmt
  } else {
    // TODO
    value = value.trim()
    return value.substr(0, fmt.length)
  }
}

// 生成首页路由
export function generateIndexRouter(data) {
  const indexRouter = [{
    path: '/',
    name: 'dashboard',
    // component: () => import('@/components/layouts/BasicLayout'),
    component: resolve => require(['@/components/layouts/TabLayout'], resolve),
    meta: { title: '首页' },
    redirect: '/dashboard/analysis',
    children: [
      ...generateChildRouters(data)
    ]
  }, {
    'path': '*', 'redirect': '/user/login', 'hidden': true
  }]
  return indexRouter
}

// 生成嵌套路由（子路由）

function generateChildRouters(data) {
  const routers = []
  for (const item of data) {
    let component = ''
    if (item.component.indexOf('layouts') >= 0) {
      component = 'components/' + item.component
    } else {
      component = 'views/' + item.component
    }

    // eslint-disable-next-line
    let URL = (item.meta.url|| '').replace(/{{([^}}]+)?}}/g, (s1, s2) => eval(s2)) // URL支持{{ window.xxx }}占位符变量
    if (isURL(URL)) {
      item.meta.url = URL
    }
    const componentPath = resolve => require(['@/' + component + '.vue'], resolve)

    // update-begin-author:xys 20210630 移除@jeecg/antd-online-mini依赖
    // let componentPath
    // if (item.component == 'modules/online/cgform/OnlCgformHeadList') {
    //   componentPath = onlineCommons.OnlCgformHeadList
    // } else if (item.component == 'modules/online/cgform/OnlCgformCopyList') {
    //   componentPath = onlineCommons.OnlCgformCopyList
    // } else if (item.component == 'modules/online/cgform/auto/OnlCgformAutoList') {
    //   componentPath = onlineCommons.OnlCgformAutoList
    // } else if (item.component == 'modules/online/cgform/auto/OnlCgformTreeList') {
    //   componentPath = onlineCommons.OnlCgformTreeList
    // } else if (item.component == 'modules/online/cgform/auto/erp/OnlCgformErpList') {
    //   componentPath = onlineCommons.OnlCgformErpList
    // } else if (item.component == 'modules/online/cgform/auto/innerTable/OnlCgformInnerTableList') {
    //   componentPath = onlineCommons.OnlCgformInnerTableList
    // } else if (item.component == 'modules/online/cgreport/OnlCgreportHeadList') {
    //   componentPath = onlineCommons.OnlCgreportHeadList
    // } else if (item.component == 'modules/online/cgreport/auto/OnlCgreportAutoList') {
    //   componentPath = onlineCommons.OnlCgreportAutoList
    // } else {
    //   componentPath = resolve => require(['@/' + component + '.vue'], resolve)
    // }
    // update-end-author:xys 20210630 移除@jeecg/antd-online-mini依赖

    const pathList = item.component.split('/')
    const menu = {
      path: item.path,
      name: item.name,
      redirect: item.redirect,
      component: componentPath,
      hidden: item.hidden,
      // component:()=> import(`@/views/${item.component}.vue`),
      meta: {
        title: item.meta.title,
        icon: item.meta.icon,
        url: item.meta.url,
        permissionList: item.meta.permissionList,
        keepAlive: item.meta.keepAlive,
        component: item.component, // 动态缓存取组件name使用 文件名称需和组件name相同
        /* update_begin author:wuxianquan date:20190908 for:赋值 */
        internalOrExternal: item.meta.internalOrExternal,
        /* update_end author:wuxianquan date:20190908 for:赋值 */
        componentName: pathList[pathList.length - 1] // 前台页面缓存
      }
    }
    if (item.alwaysShow) {
      menu.alwaysShow = true
      menu.redirect = menu.path
    }
    if (item.children && item.children.length > 0) {
      menu.children = [...generateChildRouters(item.children)]
    }
    // --update-begin----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
    // 判断是否生成路由
    if (item.route && item.route === '0') {
      // console.log(' 不生成路由 item.route：  '+item.route);
      // console.log(' 不生成路由 item.path：  '+item.path);
    } else {
      routers.push(menu)
    }
    // --update-end----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
  }
  return routers
}

/**
 * 深度克隆对象、数组
 * @param obj 被克隆的对象
 * @return 克隆后的对象
 */
export function cloneObject(obj) {
  return JSON.parse(JSON.stringify(obj))
}

/**
 * 随机生成数字
 *
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 *
 * @param1 最小值 | 长度
 * @param2 最大值
 * @return int 生成后的数字
 */
export function randomNumber() {
  // 生成 最小值 到 最大值 区间的随机数
  const random = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min)
  }
  if (arguments.length === 1) {
    const [length] = arguments
    // 生成指定长度的随机数字，首位一定不是 0
    const nums = [...Array(length).keys()].map((i) => (i > 0 ? random(0, 9) : random(1, 9)))
    return parseInt(nums.join(''))
  } else if (arguments.length >= 2) {
    const [min, max] = arguments
    return random(min, max)
  } else {
    return Number.NaN
  }
}

/**
 * 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @return string 生成的字符串
 */
export function randomString(length, chats) {
  if (!length) length = 1
  if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
  let str = ''
  for (let i = 0; i < length; i++) {
    const num = randomNumber(0, chats.length - 1)
    str += chats[num]
  }
  return str
}

/**
 * 随机生成uuid
 * @return string 生成的uuid
 */
export function randomUUID() {
  const chats = '0123456789abcdef'
  return randomString(32, chats)
}

/**
 * 下划线转驼峰
 * @param string
 * @returns {*}
 */
export function underLine2CamelCase(string) {
  return string.replace(/_([a-z])/g, function(all, letter) {
    return letter.toUpperCase()
  })
}

/**
 * 判断是否显示办理按钮
 * @param bpmStatus
 * @returns {*}
 */
export function showDealBtn(bpmStatus) {
  if (bpmStatus != '1' && bpmStatus != '3' && bpmStatus != '4') {
    return true
  }
  return false
}

/**
 * 增强CSS，可以在页面上输出全局css
 * @param css 要增强的css
 * @param id style标签的id，可以用来清除旧样式
 */
export function cssExpand(css, id) {
  const style = document.createElement('style')
  style.type = 'text/css'
  style.innerHTML = `@charset "UTF-8"; ${css}`
  // 清除旧样式
  if (id) {
    const $style = document.getElementById(id)
    if ($style != null) $style.outerHTML = ''
    style.id = id
  }
  // 应用新样式
  document.head.appendChild(style)
}

/** 用于js增强事件，运行JS代码，可以传参 */
// options 所需参数：
//    参数名         类型            说明
//    vm             VueComponent    vue实例
//    event          Object          event对象
//    jsCode         String          待执行的js代码
//    errorMessage   String          执行出错后的提示（控制台）
export function jsExpand(options = {}) {
  // 绑定到window上的keyName
  const windowKeyName = 'J_CLICK_EVENT_OPTIONS'
  if (typeof window[windowKeyName] !== 'object') {
    window[windowKeyName] = {}
  }

  // 随机生成JS增强的执行id，防止冲突
  const id = randomString(16, 'qwertyuioplkjhgfdsazxcvbnm'.toUpperCase())
  // 封装按钮点击事件
  const code = `
    (function (o_${id}) {
      try {
        (function (globalEvent, vm) {
          ${options.jsCode}
        })(o_${id}.event, o_${id}.vm)
      } catch (e) {
        o_${id}.error(e)
      }
      o_${id}.done()
    })(window['${windowKeyName}']['EVENT_${id}'])
  `
  // 创建script标签
  const script = document.createElement('script')
  // 将需要传递的参数挂载到window对象上
  window[windowKeyName]['EVENT_' + id] = {
    vm: options.vm,
    event: options.event,
    // 当执行完成时，无论如何都会调用的回调事件
    done() {
      // 执行完后删除新增的 script 标签不会撤销执行结果（已产生的结果不会被撤销）
      script.outerHTML = ''
      delete window[windowKeyName]['EVENT_' + id]
    },
    // 当js运行出错的时候调用的事件
    error(e) {
      console.group(`${options.errorMessage || '用户自定义JS增强代码运行出错'}（${new Date()}）`)
      console.error(e)
      console.groupEnd()
    }
  }
  // 将事件挂载到document中
  script.innerHTML = code
  document.body.appendChild(script)
}

/**
 * 重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateValue('sys_fill_rule', 'rule_code', value, this.model.id, callback) }
 *
 * @param tableName 被验证的表名
 * @param fieldName 被验证的字段名
 * @param fieldVal 被验证的值
 * @param dataId 数据ID，可空
 * @param callback
 */
export function validateDuplicateValue(tableName, fieldName, fieldVal, dataId, callback) {
  if (fieldVal) {
    const params = { tableName, fieldName, fieldVal, dataId }
    api.duplicateCheck(params).then(res => {
      res['success'] ? callback() : callback(res['message'])
    }).catch(err => {
      callback(err.message || err)
    })
  } else {
    callback()
  }
}

/**
 * 根据编码校验规则code，校验传入的值是否合法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateCheckRule('common', value, callback) }
 *
 * @param ruleCode 编码校验规则 code
 * @param value 被验证的值
 * @param callback
 */
export function validateCheckRule(ruleCode, value, callback) {
  if (ruleCode && value) {
    value = encodeURIComponent(value)
    api.checkRuleByCode({ ruleCode, value }).then(res => {
      res['success'] ? callback() : callback(res['message'])
    }).catch(err => {
      callback(err.message || err)
    })
  } else {
    callback()
  }
}

/**
 * 如果值不存在就 push 进数组，反之不处理
 * @param array 要操作的数据
 * @param value 要添加的值
 * @param key 可空，如果比较的是对象，可能存在地址不一样但值实际上是一样的情况，可以传此字段判断对象中唯一的字段，例如 id。不传则直接比较实际值
 * @returns {boolean} 成功 push 返回 true，不处理返回 false
 */
export function pushIfNotExist(array, value, key) {
  for (const item of array) {
    if (key && (item[key] === value[key])) {
      return false
    } else if (item === value) {
      return false
    }
  }
  array.push(value)
  return true
}

/**
 * 可用于判断是否成功
 * @type {symbol}
 */
export const succeedSymbol = Symbol()
/**
 * 可用于判断是否失败
 * @type {symbol}
 */
export const failedSymbol = Symbol()

/**
 * 使 promise 无论如何都会 resolve，除非传入的参数不是一个Promise对象或返回Promise对象的方法
 * 一般用在 Promise.all 中
 *
 * @param promise 可传Promise对象或返回Promise对象的方法
 * @returns {Promise<any>}
 */
export function alwaysResolve(promise) {
  return new Promise((resolve, reject) => {
    let p = promise
    if (typeof promise === 'function') {
      p = promise()
    }
    if (p instanceof Promise) {
      p.then(data => {
        resolve({ type: succeedSymbol, data })
      }).catch(error => {
        resolve({ type: failedSymbol, error })
      })
    } else {
      reject('alwaysResolve: 传入的参数不是一个Promise对象或返回Promise对象的方法')
    }
  })
}

/**
 * 简单实现防抖方法
 *
 * 防抖(debounce)函数在第一次触发给定的函数时，不立即执行函数，而是给出一个期限值(delay)，比如100ms。
 * 如果100ms内再次执行函数，就重新开始计时，直到计时结束后再真正执行函数。
 * 这样做的好处是如果短时间内大量触发同一事件，只会执行一次函数。
 *
 * @param fn 要防抖的函数
 * @param delay 防抖的毫秒数
 * @returns {Function}
 */
export function simpleDebounce(fn, delay = 100) {
  let timer = null
  return function() {
    const args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      fn.apply(null, args)
    }, delay)
  }
}

/**
 * 不用正则的方式替换所有值
 * @param text 被替换的字符串
 * @param checker  替换前的内容
 * @param replacer 替换后的内容
 * @returns {String} 替换后的字符串
 */
export function replaceAll(text, checker, replacer) {
  const lastText = text
  text = text.replace(checker, replacer)
  if (lastText !== text) {
    return replaceAll(text, checker, replacer)
  }
  return text
}

/**
 * 获取事件冒泡路径，兼容 IE11，Edge，Chrome，Firefox，Safari
 * 目前使用的地方：JEditableTable Span模式
 */
export function getEventPath(event) {
  const target = event.target
  const path = (event.composedPath && event.composedPath()) || event.path

  if (path != null) {
    return (path.indexOf(window) < 0) ? path.concat(window) : path
  }

  if (target === window) {
    return [window]
  }

  const getParents = (node, memo) => {
    memo = memo || []
    const parentNode = node.parentNode

    if (!parentNode) {
      return memo
    } else {
      return getParents(parentNode, memo.concat(parentNode))
    }
  }
  return [target].concat(getParents(target), window)
}

/**
 * 根据组件名获取父级
 * @param vm
 * @param name
 * @returns {Vue | null|null|Vue}
 */
export function getVmParentByName(vm, name) {
  const parent = vm.$parent
  if (parent && parent.$options) {
    if (parent.$options.name === name) {
      return parent
    } else {
      const res = getVmParentByName(parent, name)
      if (res) {
        return res
      }
    }
  }
  return null
}

/**
 * 根据配置返回默认值
 * @param vm
 * @param name
 * @returns { Object }
 */
export function getDefValue(value) {
  if (value === '${currentYear}') {
    return new Date().getFullYear()
  } else if (value === '${currentDate}') {
    let currentDate = new Date()
    currentDate = currentDate.getFullYear() + '-' + currentDate.getMonth() + 1 + '-' + currentDate.getDate()
    return currentDate
  } else {
    return value
  }
}

/**
 * 根据配置返回是全匹配参数或模糊搜索参数
 * @param vm
 * @param param { Object } 查询参数
 * @param excludeKeys { Array } 不需要模糊查询的参数
 * @returns { Object }
 */
export function getLikeOrEqQueryParam(param, excludeKeys) {
  if (window._CONFIG['searchType'] !== 'like') {
    return param
  }
  excludeKeys = excludeKeys || []
  const queryParam = { ...param }
  Object.keys(queryParam).forEach(key => {
    if (excludeKeys.includes(key)) {
      return false
    }
    const item = queryParam[key]
    const format = ['YYYY-MM-DD', 'YYYY-MM-DD HH:mm:ss', 'YYYY/MM/DD', 'YYYY/MM/DD HH:mm:ss'] // 严格模式判断参数是否为这四种格式字符串、日期类型
    if ((item !== '' && item !== null && item !== undefined) && isNaN(item) && !moment(item, format, true).isValid()) { // 空、数字类型、日期类型不拼接
      queryParam[key] = '*' + item + '*'
    }
  })
  return queryParam
}

/**
 * 根据数值转换中文大写
 * @param vm
 * @param currencyDigits
 * @returns {number}
 */

export function convertCurrency(currencyDigits) {
  var MAXIMUM_NUMBER = 1000000000000.00

  var CN_ZERO = '零'
  var CN_ONE = '壹'
  var CN_TWO = '贰'
  var CN_THREE = '叁'
  var CN_FOUR = '肆'
  var CN_FIVE = '伍'
  var CN_SIX = '陆'
  var CN_SEVEN = '柒'
  var CN_EIGHT = '捌'
  var CN_NINE = '玖'
  var CN_TEN = '拾'
  var CN_HUNDRED = '佰'
  var CN_THOUSAND = '仟'
  var CN_TEN_THOUSAND = '万'
  var CN_HUNDRED_MILLION = '亿'
  var CN_SYMBOL = '人民币'
  var CN_DOLLAR = '元'
  var CN_TEN_CENT = '角'
  var CN_CENT = '分'
  var CN_INTEGER = '整'

  var integral // integral part
  var decimal // decimal part
  var outputCharacters = '' // result.
  var parts
  var digits, radices, bigRadices, decimals
  var zeroCount
  var i, p, d
  var quotient, modulus

  if (currencyDigits != null) {
    currencyDigits = currencyDigits.toString()
    currencyDigits = currencyDigits.replace(/,/g, '') // Remove comma delimiters.
    currencyDigits = currencyDigits.replace(/^0+/, '') // Trim zeros at the beginning.

    if (Number(currencyDigits) < MAXIMUM_NUMBER) {
      if (Number(currencyDigits) < 0) {
        outputCharacters += '负'
        currencyDigits = Math.abs(Number(currencyDigits)).toString()
      }

      parts = currencyDigits.split('.') // separate the number by decimal point
      if (parts.length > 1) {
        integral = parts[0]
        decimal = parts[1]
        decimal = decimal.substr(0, 2)// two decimal places
      } else {
        integral = parts[0]
        decimal = ''
      }

      digits = [CN_ZERO, CN_ONE, CN_TWO, CN_THREE, CN_FOUR, CN_FIVE, CN_SIX, CN_SEVEN, CN_EIGHT, CN_NINE]
      radices = ['', CN_TEN, CN_HUNDRED, CN_THOUSAND]
      bigRadices = ['', CN_TEN_THOUSAND, CN_HUNDRED_MILLION]
      decimals = [CN_TEN_CENT, CN_CENT]

      if (Number(integral) > 0) {
        zeroCount = 0
        for (i = 0; i < integral.length; i++) {
          p = integral.length - i - 1
          d = integral.substr(i, 1)
          quotient = p / 4
          modulus = p % 4
          if (d == '0') {
            zeroCount++
          } else {
            if (zeroCount > 0) {
              outputCharacters += digits[0]
            }
            zeroCount = 0
            outputCharacters += digits[Number(d)] + radices[modulus]
          }
          if (modulus == 0 && zeroCount < 4) {
            outputCharacters += bigRadices[quotient]
          }
        }
        outputCharacters += CN_DOLLAR
      }

      if (decimal != '') {
        for (i = 0; i < decimal.length; i++) {
          d = decimal.substr(i, 1)
          if (d != '0') {
            outputCharacters += digits[Number(d)] + decimals[i]
          }
        }
      }
      if (outputCharacters == '') {
        outputCharacters = CN_ZERO + CN_DOLLAR
      }
      if (decimal == '') {
        outputCharacters += CN_INTEGER
      }
      outputCharacters = '' + outputCharacters + ''
    }
  }
  return outputCharacters
}
